Paul Sawers writes that Zed has launched Delta, a collaborative development platform now in public beta that replaces pull requests with shared threads preserving the full conversation between developers and coding agents. The move responds to both volume pressure on GitHub — monthly commits jumped from roughly 1 billion in 2025 to 2.9 billion by August 2026 — and a structural mismatch: when much of the reasoning behind a change happens inside an agent conversation, a bare diff gives reviewers little context. Zed has already disabled pull requests on Delta's own repository, where 33 developers have landed 570 changes to main through threads, and co-founder Nathan Sobo expects the company to fully leave GitHub within a few months.
- DeltaDB, the version control layer beneath Delta, records individual edits and conversation events between Git commits, a finer granularity than Git's commit-based model; Zed calls these individual records "deltas."
- Sobo predicts the thread will replace the commit or branch as the fundamental unit of software development, with commits remaining only as checkpoints.
- Competitors share the thesis: SpaceX-owned Cursor launched Origin in August 2026, and GitLab has Project Switch in private beta.
- Delta works with existing Git repositories, so contributors who don't adopt it can still submit conventional pull requests; the platform is free during public beta with paid plans to follow.
- Zed raised $32 million from Sequoia Capital in August 2025, a round that also teased DeltaDB.
- DeltaDB, the version control layer beneath Delta, records individual edits and conversation events between Git commits, a finer granularity than Git's commit-based model; Zed calls these individual records "deltas."
- Sobo predicts the thread will replace the commit or branch as the fundamental unit of software development, with commits remaining only as checkpoints.
- Competitors share the thesis: SpaceX-owned Cursor launched Origin in August 2026, and GitLab has Project Switch in private beta.
- Delta works with existing Git repositories, so contributors who don't adopt it can still submit conventional pull requests; the platform is free during public beta with paid plans to follow.
- Zed raised $32 million from Sequoia Capital in August 2025, a round that also teased DeltaDB.
Emmimal P Alexander writes that coding agents struggle with long projects not because they lack context, but because they fail to distinguish which historical requirements remain valid. The author proposes an "intent continuity" pipeline—implemented in pure Python without LLM calls or vector databases—that extracts structured rules from chat logs and verifies them against a domain schema before passing them to the agent. This process ensures that superseded decisions are dropped while still-relevant constraints are prioritized, preventing agents from making mistakes based on outdated instructions.
- A basic lexical search only recovered 57% of required information in tests.
- Adding a verification layer increased requirement recovery to 100%.
- The author's "intent-aware" approach outperformed standard keyword/vector searches by correctly filtering out superseded or irrelevant data.
- The entire implementation is built using only the Python standard library to isolate the effects of the retrieval logic from model performance.
- A basic lexical search only recovered 57% of required information in tests.
- Adding a verification layer increased requirement recovery to 100%.
- The author's "intent-aware" approach outperformed standard keyword/vector searches by correctly filtering out superseded or irrelevant data.
- The entire implementation is built using only the Python standard library to isolate the effects of the retrieval logic from model performance.
Mantis is a modular, stack-agnostic toolkit of security review skills designed for AI coding agents to autonomously discover, reproduce, and patch vulnerabilities. It provides a sequential pipeline—ranging from architecture synthesis and threat modeling to automated vulnerability research and remediation—to enable continuous and iterative defensive security reviews in an isolated environment.
- Designed for use with various coding agent frameworks like Gemini CLI or Antigravity SDK.
- Emphasizes the need for execution within sandboxed environments (e.g., gVisor, Docker) due to the risk of AI-generated code.
- Includes a "Snapshot Model" that allows for pinned, authoritative security passes on living codebases via non-destructive synchronization.
- Features an extensive set of specialized skills including `mantis-researcher` for flaw sweeping and `mantis-patch` for automated remediation.
- Designed for use with various coding agent frameworks like Gemini CLI or Antigravity SDK.
- Emphasizes the need for execution within sandboxed environments (e.g., gVisor, Docker) due to the risk of AI-generated code.
- Includes a "Snapshot Model" that allows for pinned, authoritative security passes on living codebases via non-destructive synchronization.
- Features an extensive set of specialized skills including `mantis-researcher` for flaw sweeping and `mantis-patch` for automated remediation.
Anurag Singh writes that using Claude Code's auto mode can be frustrating when the tool constantly requests permission for terminal commands, which often breaks its autonomy. To solve this while maintaining security, he suggests running Claude Code inside a virtual machine (VM) with Ubuntu; this provides a safe sandbox where "auto mode" can run freely without risking personal files or credentials on the host computer.
- The author uses VirtualBox to create the VM environment.
- Running in auto mode within a VM allows for background file editing, testing, and error handling without constant human interruption.
- Even with built-in sandboxing in Claude Code, Singh argues that a VM is safer because it provides full operating system separation.
- After tasks are complete, the user should review Git diffs and run tests before moving code from the VM to the main project.
- The author uses VirtualBox to create the VM environment.
- Running in auto mode within a VM allows for background file editing, testing, and error handling without constant human interruption.
- Even with built-in sandboxing in Claude Code, Singh argues that a VM is safer because it provides full operating system separation.
- After tasks are complete, the user should review Git diffs and run tests before moving code from the VM to the main project.
Anurag Singh writes that providing Claude Code with read-only access to a SaaS application's server logs allowed the coding agent to identify and propose fixes for real performance issues. By observing error patterns, traces, and metrics directly within the environment rather than relying on manual bug reports, the agent was able to autonomously trace bugs back to specific lines of code across various files.
- The experiment highlights a shift toward AI agents joining the "on-call" workflow by inspecting live operational telemetry.
- To mitigate security risks, it is recommended using Model Context Protocol (MCP) servers to restrict an agent's tools to read-only actions.
- Major observability companies like Sentry and Datadog are already implementing similar features to automate root cause analysis and pull request generation.
- The experiment highlights a shift toward AI agents joining the "on-call" workflow by inspecting live operational telemetry.
- To mitigate security risks, it is recommended using Model Context Protocol (MCP) servers to restrict an agent's tools to read-only actions.
- Major observability companies like Sentry and Datadog are already implementing similar features to automate root cause analysis and pull request generation.
rohitg00 writes agentmemory, a persistent memory solution for AI coding agents designed to eliminate the need for repetitive context re-explanation between sessions. By silently capturing tool usage and session details through various hooks (including native plugins for Claude Code, Cursor, and Codex), it compresses observations into searchable structured memories that are injected back into subsequent conversations. The system utilizes a hybrid retrieval approach combining BM25 keyword matching, vector embeddings, and knowledge graph traversal to ensure high-quality context injection with significant token savings compared to standard long-context prompting.
- Supports multiple agents including Claude Code, Cursor, GitHub Copilot CLI, Devin, Gemini CLI, OpenCode, Hermes, and more via MCP or native plugins.
- Employs a 4-tier memory consolidation model: Working (raw observations), Episodic (session summaries), Semantic (extracted facts), and Procedural (workflow patterns).
- Offers high retrieval accuracy; real-world benchmarks show up to 95.2% R@5 on the LongMemEval-S dataset.
- Reduces LLM token costs significantly, claiming ~170K tokens per year compared to millions when pasting full context.
- Includes a real-time visualizer (on port 3113) and an observability console for monitoring memory writes, traces, and graph structures.
- Supports multiple agents including Claude Code, Cursor, GitHub Copilot CLI, Devin, Gemini CLI, OpenCode, Hermes, and more via MCP or native plugins.
- Employs a 4-tier memory consolidation model: Working (raw observations), Episodic (session summaries), Semantic (extracted facts), and Procedural (workflow patterns).
- Offers high retrieval accuracy; real-world benchmarks show up to 95.2% R@5 on the LongMemEval-S dataset.
- Reduces LLM token costs significantly, claiming ~170K tokens per year compared to millions when pasting full context.
- Includes a real-time visualizer (on port 3113) and an observability console for monitoring memory writes, traces, and graph structures.
Sara A. Metwalli writes that coding agents differ from basic autocomplete or assistants because they can interact with their environment by examining repositories, modifying files, and running tests in a loop. To use them effectively, developers should provide clear constraints and context rather than just long prompts, following a workflow of inspection, planning, implementation, testing, and review. Instead of delegating massive tasks like rewriting entire applications, users should break work into small, testable problems to maintain control over the architectural integrity and quality of the generated code.
- Agents are best suited for exploratory or multi-step tasks such as finding/fixing bugs or investigating failing tests.
- A recommended prompt structure includes a Goal, Context, Constraints, Acceptance Criteria, and Validation steps.
- The developer's role shifts from writing raw code to directing, assessing, and coordinating complex code-generating systems.
A successful agentic request should include five specific elements rather than just long prompts:
```text
Goal: What you want to achieve »
Context: Specific files or architecture to inspect »
Constraints: Rules/boundaries the agent must follow »
Acceptance criteria: The definition of a "finished" task, e.g., passing tests »
Validation: How to verify success, e.g., run specific test commands »
```
- Agents are best suited for exploratory or multi-step tasks such as finding/fixing bugs or investigating failing tests.
- A recommended prompt structure includes a Goal, Context, Constraints, Acceptance Criteria, and Validation steps.
- The developer's role shifts from writing raw code to directing, assessing, and coordinating complex code-generating systems.
A successful agentic request should include five specific elements rather than just long prompts:
```text
Goal: What you want to achieve »
Context: Specific files or architecture to inspect »
Constraints: Rules/boundaries the agent must follow »
Acceptance criteria: The definition of a "finished" task, e.g., passing tests »
Validation: How to verify success, e.g., run specific test commands »
```
Yiwei Ho writes about open-slide, a slide framework built for coding agents where you describe your deck in natural language and the agent writes React components rendered on a fixed 1920×1080 canvas. It handles navigation, hot reload, and present mode so the agent can focus on content rather than boilerplate.
- Works with any coding agent (Claude Code, Codex, Cursor, etc.)
- In-browser inspector: click any element to attach a comment, then run `/apply-comments` to have the agent apply all pending edits
- Integrated svgl catalogue for searching and dropping in brand logo SVGs
- Exports to self-contained static HTML or print-ready PDF with one command
- Presenter mode includes speaker notes, timer, and current/next slide preview
- Works with any coding agent (Claude Code, Codex, Cursor, etc.)
- In-browser inspector: click any element to attach a comment, then run `/apply-comments` to have the agent apply all pending edits
- Integrated svgl catalogue for searching and dropping in brand logo SVGs
- Exports to self-contained static HTML or print-ready PDF with one command
- Presenter mode includes speaker notes, timer, and current/next slide preview
Michael Nuñez writes about Slack Code, a new product that embeds AI coding agents'', including Anthropic's Claude Code, Cognition's Devin, GitHub Copilot, and Vercel's agent'', into dedicated Slack channels where entire teams can watch, steer, review, and ship software together. The pitch reframes AI coding from a solitary terminal exercise into a "multiplayer" newsroom workflow: tagging an agent spawns a project-specific channel with live code diffs, previews, and a running plan, then archives into a searchable audit trail. Slack argues that with generation no longer the scarce step, the bottleneck has shifted to human judgment, taste, and craft work any team member can contribute to in a shared channel.
- Cognition reported internal merged PRs up 10x while headcount rose only 40%, with engineers simultaneously managing "dozens of agents."
- Security model: agents inherit the invoking user's ACLs with no bot-level or god permissions; Devin sandboxes run with "minimum viable access" and an optional
- Cognition reported internal merged PRs up 10x while headcount rose only 40%, with engineers simultaneously managing "dozens of agents."
- Security model: agents inherit the invoking user's ACLs with no bot-level or god permissions; Devin sandboxes run with "minimum viable access" and an optional
Hadley Wickham writes that modern coding agents, which have transformed software development, fundamentally rely on just six core functions that enable a language model to navigate and modify a codebase like a human developer. By deconstructing these tools into read, write, edit, list, search, and execute commands, the author demonstrates how to construct a minimal, fully functional coding agent in R. He emphasizes that while a general shell command can substitute for many tools, implementing dedicated functions with strict path validation significantly improves both security and efficiency, preventing accidental exposure of sensitive files or unintended system modifications.
- The minimal viable agent requires only three functions: read file, write file, and run command.
- Direct shell execution acts as a catch-all but introduces significant security risks and cross-platform inconsistencies.
- Dedicated search and list functions allow for precise path validation, blocking access to hidden dotfiles and directories outside the project root.
- An edit function that swaps exact text chunks is far faster and cheaper than rewriting entire files, while also failing loudly on mismatches instead of corrupting code.
- The minimal viable agent requires only three functions: read file, write file, and run command.
- Direct shell execution acts as a catch-all but introduces significant security risks and cross-platform inconsistencies.
- Dedicated search and list functions allow for precise path validation, blocking access to hidden dotfiles and directories outside the project root.
- An edit function that swaps exact text chunks is far faster and cheaper than rewriting entire files, while also failing loudly on mismatches instead of corrupting code.
